Section: New Results

Models and abstractions for distributed systems

Randomized loose renaming in O(loglog n) time

Participant : George Giakkoupis.

Renaming is a classic distributed coordination task in which a set of processes must pick distinct identifiers from a small namespace. In [24] , we consider the time complexity of this problem when the namespace is linear in the number of participants, a variant known as loose renaming. We give a non-adaptive algorithm with $O(loglogn)$ (individual) step complexity, where $n$ is a known upper bound on contention, and an adaptive algorithm with step complexity $O\left({(loglogk)}^2\right)$, where $k$ is the actual contention in the execution. We also present a variant of the adaptive algorithm which requires $O(kloglogk)$ total process steps. All upper bounds hold with high probability against a strong adaptive adversary. We complement the algorithms with an $\Omega (loglogn)$ expected time lower bound on the complexity of randomized renaming using test-and-set operations and linear space. The result is based on a new coupling technique, and is the first to apply to non-adaptive randomized renaming. Since our algorithms use $O\left(n\right)$ test-and-set objects, our results provide matching bounds on the cost of loose renaming in this setting.

This work was done in collaboration with Dan Alistarh, James Aspnes, and Philipp Woelfel.

An O(sqrt n) space bound for obstruction-free leader election

Participant : George Giakkoupis.

In [32] we present a deterministic obstruction-free implementation of leader election from $O\left(\sqrt{n}\right)$ atomic $O(logn)$-bit registers in the standard asynchronous shared memory system with $n$ processes. We provide also a technique to transform any deterministic obstruction-free algorithm, in which any process can finish if it runs for $b$ steps without interference, into a randomized wait-free algorithm for the oblivious adversary, in which the expected step complexity is polynomial in $n$ and $b$. This transformation allows us to combine our obstruction-free algorithm with the leader election algorithm by Giakkoupis and Woelfel (2012), to obtain a fast randomized leader election (and thus test-and-set) implementation from $O\left(\sqrt{n}\right)$ $O(logn)$-bit registers, that has expected step complexity $O\left({log}^{*}n\right)$ against the oblivious adversary. Our algorithm provides the first sub-linear space upper bound for obstruction-free leader election. A lower bound of $\Omega (logn)$ has been known since 1989 (Styer and Peterson, 1989). Our research is also motivated by the long-standing open problem whether there is an obstruction-free consensus algorithm which uses fewer than $n$ registers.

This work was done in collaboration with Maryam Helmi, Lisa Higham, and Philipp Woelfel.

Broadcast in recurrent dynamic systems

Participants : Michel Raynal, Julien Stainer.

This work [50] proposes a simple broadcast algorithm suited to dynamic systems where links can repeatedly appear and disappear. The algorithm is proved correct and a simple improvement is introduced, that reduces the number and the size of control messages. As it extends in a simple way a classical network traversal algorithm (due to A. Segall, 1983) to the dynamic context, the proposed algorithm has also pedagogical flavor.

This work has been done in collaboration with Jiannong Cao and Weigang Wu.

Computing in the presence of concurrent solo executions

Participants : Michel Raynal, Julien Stainer.

In a wait-free model any number of processes may crash. A process runs solo when it computes its local output without receiving any information from other processes, either because they crashed or they are too slow. While in wait-free shared-memory models at most one process may run solo in an execution, any number of processes may have to run solo in an asynchronous wait-free message-passing model. This work [47] is on the computability power of models in which several processes may concurrently run solo. We introduced a family of round-based wait-free models, called the $d$-solo models, $1\le d\le n$, where up to $d$ processes may run solo. Then we gave a characterization of the colorless tasks that can be solved in each $d$-solo model. We also introduced the $(d,ϵ)$-solo approximate agreement task, which generalizes $ϵ$-approximate agreement, and proves that $(d,ϵ)$-solo approximate agreement can be solved in the $d$-solo model, but cannot be solved in the $(d+1)$-solo model. We also studied the relation linking $d$-set agreement and $(d,ϵ)$-solo approximate agreement in asynchronous wait-free message-passing systems. These results establish for the first time a hierarchy of wait-free models that, while weaker than the basic read/write model, are nevertheless strong enough to solve non-trivial tasks.

This work was done in collaboration with Maurice Herlihy and Sergio Rajsbaum.

Relating message-adversaries and failure detectors

Participants : Michel Raynal, Julien Stainer.

A message adversary is a daemon that suppresses messages in round-based message-passing synchronous systems in which no process crashes. A property imposed on a message adversary defines a subset of messages that cannot be eliminated by the adversary. It has recently been shown that when a message adversary is constrained by a property denoted TOUR (for tournament), the corresponding synchronous system and the asynchronous crash-prone read/write system have the same computability power for task solvability. In this work [39] we introduced new message adversary properties (denoted SOURCE and QUORUM), and shown that the synchronous round-based systems whose adversaries are constrained by these properties are characterizations of classical asynchronous crash-prone systems (1) in which processes communicate through atomic read/write registers or point-to-point message-passing, and (2) enriched with failure detectors such as $\Omega$ and $\Sigma$. Hence these properties characterize maximal adversaries, in the sense that they define strongest message adversaries equating classical asynchronous crash-prone systems. They consequently provide strong relations linking round-based synchrony weakened by message adversaries with asynchrony restricted with failure detectors. This not only enriches our understanding of the synchrony/asynchrony duality, but also allows for the establishment of a meaningful hierarchy of property-constrained message adversaries.

A hierarchy of agreement problems from simultaneous consensus to set agreement

Participants : Michel Raynal, Julien Stainer.

In this work [38] we investigated the relation linking the $s$-simultaneous consensus problem and the $k$-set agreement problem in wait-free message-passing systems. To this end, we defined the $(s,k)$-SSA problem which captures jointly both problems: each process proposes a value, executes $s$ simultaneous instances of a $k$-set agreement algorithm, and has to decide a value so that no more than $sk$ different values are decided. We also introduced a new failure detector class denoted $Z_{s,k}$, which is made up of two components, one focused on the "shared memory object" that allows the processes to cooperate, and the other focused on the liveness of $(s,k)$-SSA algorithms. A novelty of this failure detector lies in the fact that the definition of its two components are intimately related. We designed a $Z_{s,k}$-based algorithm that solves the $(s,k)$-SSA problem, and shown that the "shared memory"-oriented part of $Z_{s,k}$ is necessary to solve the $(s,k)$-SSA problem (this generalizes and refines a previous result that showed that the generalized quorum failure detector ${\Sigma }_k$ is necessary to solve $k$-set agreement). We finally, investigated the structure of the family of $(s,k)$-SSA problems and introduced generalized (asymmetric) simultaneous set agreement problems in which the parameter $k$ can differ in each underlying $k$-set agreement instance. Among other points, it shows that, for $s,k\hspace{0.17em}>\hspace{0.17em}1$, (a) the $(sk,1)$-SSA problem is strictly stronger that the $(s,k)$-SSA problem which is itself strictly stronger than the $(1,ks)$-SSA problem, and (b) there are pairs $(s_1,k_1)$ and $(s_2,k_2)$ such that $s_1{k}_1\hspace{0.17em}=\hspace{0.17em}{s}_2{k}_2$ and $(s_1,k_1)$-SSA and $(s_2,k_2)$-SSA are incomparable.